<?php

/*
 * Contrôleur s'occupant de tout les calculs
 *
 * Controller/CalculatorController.php
 */

namespace RHX\Controller;

use RHX\Helper\RHDateTime;
use RHX\Model\Object\XRules;
use RHX\Model\Object\XData;
use RHX\Model\Table\EmployeTemplateTable;
use Zend\View\Model\JsonModel;
use RHX\Model\Table\PlanningSemaineTable;
use RHX\Model\Object\PlanningSemaine;
use RHX\Model\Object\EmployeTemplate;
use RHX\Model\Object\Periode;
use RHX\Model\Table\PeriodeTable;
use RHX\Model\Table\EmployeTable;
use RHX\Model\Table\PeriodeSemaineTable;
use RHX\Model\Code\CodeController;

class CalculatorController extends RHXController {

    /**
     * Calcul des Cumul d'heure pour une ligne dans les Planning Type
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function cumulTemplateAction() {
	// POST
	$post = $this->getRequest()
		->getPost();

	// Table Employe Template
	$templateTable = new EmployeTemplateTable($this->getAdapter());

	/**
	 * Template en cours
	 * 
	 * @var \RHX\Model\Object\EmployeTemplate
	 */
	$template = $templateTable->get($post->id);

	// Heure Prévues
	$cumulHeure = new RHDateTime();
	$cumulHeure->setTime();

	// Temps de pause
	$tpsPause = '00:30';

	// Calcul des Heures
	// Lundi
	$lundiCode = (int) $template->lundi_code;
	if ($lundiCode == XRules::Present || $lundiCode == XRules::ProblemeRetardDepartAnticipe || $lundiCode == XRules::ArretMaladie1 || $lundiCode == XRules::ArretMaladie2 || $lundiCode == XRules::CongePaye || $lundiCode == XRules::CongeMaternite || $lundiCode == XRules::CongeMaternitePere || $lundiCode == XRules::CongePayeExceptionnel || $lundiCode == XRules::EcoleFormation || $lundiCode == XRules::EcoleFormationAlternance || $lundiCode == XRules::EcoleFormationEmploye || $lundiCode == XRules::EcoleFormationIntegration || $lundiCode == XRules::Ferie1 || $lundiCode == XRules::Ferie2 || $lundiCode == XRules::Ferie3) {
	    $diff = RHDateTime::diffHours($template->lundi_sortie, $template->lundi_entree);
	    if ((int) $template->lundi_pause) {
		$diff = RHDateTime::diffHours($diff, $tpsPause);
	    }
	    $cumulHeure->addHours($diff, false);
	}
	// Mardi
	$mardiCode = (int) $template->mardi_code;
	if ($mardiCode == XRules::Present || $mardiCode == XRules::ProblemeRetardDepartAnticipe || $mardiCode == XRules::ArretMaladie1 || $mardiCode == XRules::ArretMaladie2 || $mardiCode == XRules::CongePaye || $mardiCode == XRules::CongeMaternite || $mardiCode == XRules::CongeMaternitePere || $mardiCode == XRules::CongePayeExceptionnel || $mardiCode == XRules::EcoleFormation || $mardiCode == XRules::EcoleFormationAlternance || $mardiCode == XRules::EcoleFormationEmploye || $mardiCode == XRules::EcoleFormationIntegration || $mardiCode == XRules::Ferie1 || $mardiCode == XRules::Ferie2 || $mardiCode == XRules::Ferie3) {
	    $diff = RHDateTime::diffHours($template->mardi_sortie, $template->mardi_entree);
	    if ((int) $template->mardi_pause) {
		$diff = RHDateTime::diffHours($diff, $tpsPause);
	    }
	    $cumulHeure->addHours($diff, false);
	}
	// Mercredi
	$mercrediCode = (int) $template->mercredi_code;
	if ($mercrediCode == XRules::Present || $mercrediCode == XRules::ProblemeRetardDepartAnticipe || $mercrediCode == XRules::ArretMaladie1 || $mercrediCode == XRules::ArretMaladie2 || $mercrediCode == XRules::CongePaye || $mercrediCode == XRules::CongeMaternite || $mercrediCode == XRules::CongeMaternitePere || $mercrediCode == XRules::CongePayeExceptionnel || $mercrediCode == XRules::EcoleFormation || $mercrediCode == XRules::EcoleFormationAlternance || $mercrediCode == XRules::EcoleFormationEmploye || $mercrediCode == XRules::EcoleFormationIntegration || $mercrediCode == XRules::Ferie1 || $mercrediCode == XRules::Ferie2 || $mercrediCode == XRules::Ferie3) {
	    $diff = RHDateTime::diffHours($template->mercredi_sortie, $template->mercredi_entree);
	    if ((int) $template->mercredi_pause) {
		$diff = RHDateTime::diffHours($diff, $tpsPause);
	    }
	    $cumulHeure->addHours($diff, false);
	}
	// Jeudi
	$jeudiCode = (int) $template->jeudi_code;
	if ($jeudiCode == XRules::Present || $jeudiCode == XRules::ProblemeRetardDepartAnticipe || $jeudiCode == XRules::ArretMaladie1 || $jeudiCode == XRules::ArretMaladie2 || $jeudiCode == XRules::CongePaye || $jeudiCode == XRules::CongeMaternite || $jeudiCode == XRules::CongeMaternitePere || $jeudiCode == XRules::CongePayeExceptionnel || $jeudiCode == XRules::EcoleFormation || $jeudiCode == XRules::EcoleFormationAlternance || $jeudiCode == XRules::EcoleFormationEmploye || $jeudiCode == XRules::EcoleFormationIntegration || $jeudiCode == XRules::Ferie1 || $jeudiCode == XRules::Ferie2 || $jeudiCode == XRules::Ferie3) {
	    $diff = RHDateTime::diffHours($template->jeudi_sortie, $template->jeudi_entree);
	    if ((int) $template->jeudi_pause) {
		$diff = RHDateTime::diffHours($diff, $tpsPause);
	    }
	    $cumulHeure->addHours($diff, false);
	}
	// Vendredi
	$vendrediCode = (int) $template->vendredi_code;
	if ($vendrediCode == XRules::Present || $vendrediCode == XRules::ProblemeRetardDepartAnticipe || $vendrediCode == XRules::ArretMaladie1 || $vendrediCode == XRules::ArretMaladie2 || $vendrediCode == XRules::CongePaye || $vendrediCode == XRules::CongeMaternite || $vendrediCode == XRules::CongeMaternitePere || $vendrediCode == XRules::CongePayeExceptionnel || $vendrediCode == XRules::EcoleFormation || $vendrediCode == XRules::EcoleFormationAlternance || $vendrediCode == XRules::EcoleFormationEmploye || $vendrediCode == XRules::EcoleFormationIntegration || $vendrediCode == XRules::Ferie1 || $vendrediCode == XRules::Ferie2 || $vendrediCode == XRules::Ferie3) {
	    $diff = RHDateTime::diffHours($template->vendredi_sortie, $template->vendredi_entree);
	    if ((int) $template->vendredi_pause) {
		$diff = RHDateTime::diffHours($diff, $tpsPause);
	    }
	    $cumulHeure->addHours($diff, false);
	}
	// Samedi
	$samediCode = (int) $template->samedi_code;
	if ($samediCode == XRules::Present || $samediCode == XRules::ProblemeRetardDepartAnticipe || $samediCode == XRules::ArretMaladie1 || $samediCode == XRules::ArretMaladie2 || $samediCode == XRules::CongePaye || $samediCode == XRules::CongeMaternite || $samediCode == XRules::CongeMaternitePere || $samediCode == XRules::CongePayeExceptionnel || $samediCode == XRules::EcoleFormation || $samediCode == XRules::EcoleFormationAlternance || $samediCode == XRules::EcoleFormationEmploye || $samediCode == XRules::EcoleFormationIntegration || $samediCode == XRules::Ferie1 || $samediCode == XRules::Ferie2 || $samediCode == XRules::Ferie3) {
	    $diff = RHDateTime::diffHours($template->samedi_sortie, $template->samedi_entree);
	    if ((int) $template->samedi_pause) {
		$diff = RHDateTime::diffHours($diff, $tpsPause);
	    }
	    $cumulHeure->addHours($diff, false);
	}
	// Dimanche
	$dimancheCode = (int) $template->dimanche_code;
	if ($dimancheCode == XRules::Present || $dimancheCode == XRules::ProblemeRetardDepartAnticipe || $dimancheCode == XRules::ArretMaladie1 || $dimancheCode == XRules::ArretMaladie2 || $dimancheCode == XRules::CongePaye || $dimancheCode == XRules::CongeMaternite || $dimancheCode == XRules::CongeMaternitePere || $dimancheCode == XRules::CongePayeExceptionnel || $dimancheCode == XRules::EcoleFormation || $dimancheCode == XRules::EcoleFormationAlternance || $dimancheCode == XRules::EcoleFormationEmploye || $dimancheCode == XRules::EcoleFormationIntegration || $dimancheCode == XRules::Ferie1 || $dimancheCode == XRules::Ferie2 || $dimancheCode == XRules::Ferie3) {
	    $diff = RHDateTime::diffHours($template->dimanche_sortie, $template->dimanche_entree);
	    if ((int) $template->dimanche_pause) {
		$diff = RHDateTime::diffHours($diff, $tpsPause);
	    }
	    $cumulHeure->addHours($diff, false);
	}

	// Assignation de la valeur
	$template->heure_prevues = $cumulHeure->totalHours();

	// Sauvegarde ou non
	if ($post->save == 'on') {
	    $templateTable->save($template);
	}

	// Employé
	$employe	 = $template->getEmploye();
	$dataCP		 = $employe->getDataCP();
	$cumulFloat	 = RHDateTime::toFloat($cumulHeure->totalHours());
	$state		 = EmployeTemplate::EQUAL;
	if ($cumulFloat < $dataCP['hebdo']) {
	    $state = EmployeTemplate::LESS_THAN;
	}
	elseif ($cumulFloat > $dataCP['hebdo']) {
	    $state = EmployeTemplate::GREATER_THAN;
	}
	elseif ($cumulFloat == $dataCP['hebdo']) {
	    $state = EmployeTemplate::EQUAL;
	}

	// Valeur de retour
	$data = array(
	    'template'	 => $template,
	    'state'		 => $state,
	);

	// JSON ou HTML
	if ($post->json == 'on') {
	    return new JsonModel($data);
	}
	else {
	    // Changement de layout
	    $this->layout('layout/ajax');

	    return $data;
	}
    }

    /**
     * Calcul d'une ligne
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function calculRowPlanningAction() {
	// POST
	$post = $this->getRequest()
		->getPost();

	// Table Planning Semaine
	$planningTable = new PlanningSemaineTable($this->getAdapter());

	// Planning En cours
	$planning = $planningTable->get($post->id);

	// Template
	$template = $planning->getTemplate();

	// Calcul des données pour les jour de la semaine
	$dataLundi	 = $this->calculOneDay($planning, $template, 'lundi');
	$dataMardi	 = $this->calculOneDay($planning, $template, 'mardi');
	$dataMercredi	 = $this->calculOneDay($planning, $template, 'mercredi');
	$dataJeudi	 = $this->calculOneDay($planning, $template, 'jeudi');
	$dataVendredi	 = $this->calculOneDay($planning, $template, 'vendredi');
	$dataSamedi	 = $this->calculOneDay($planning, $template, 'samedi');
	$dataDimanche	 = $this->calculOneDay($planning, $template, 'dimanche');

	// Total
	$total = $this->getTotal($dataLundi, $dataMardi, $dataMercredi, $dataJeudi, $dataVendredi, $dataSamedi, $dataDimanche);

	// Heure non plannifié
	$heureNonPlannifie = $this->getHeureNonPlannifie($planning->matricule, $planning->lundi);

	$result = array(
	    'total'			 => $total,
	    'heureNonPlannifie'	 => RHDateTime::toTime(number_format($heureNonPlannifie, 2, ',', '')),
	);

	// Debub
	//$this->Debug("calculRowPlanningAction() : " . json_encode($result));


	if ($post->json == 'on') {
	    return new JsonModel($result);
	}
	else {
	    return array($result);
	}
    }

    /**
     * Calcul Des Informations d'une Journée
     *
     * @param \RHX\Model\Object\PlanningSemaine $planning
     * @param \RHX\Model\Object\EmployeTemplate $template
     * @param type $prefix
     * @return \RHX\Model\Object\XData
     */
    public function calculOneDay(PlanningSemaine $planning, EmployeTemplate $template, $prefix = 'lundi') {
	$data = new XData();

	// Préparation des variables dynamiques
	$prefixCode	 = $prefix . '_code';
	$prefixEntree	 = $prefix . '_entree';
	$prefixSortie	 = $prefix . '_sortie';
	$prefixPause	 = $prefix . '_pause';
	$prefixRepas	 = $prefix . '_repas';

	// Assignation et Préparation des variables
	$code	 = (int) $planning->$prefixCode;
	$entree	 = $planning->$prefixEntree;
	$sortie	 = $planning->$prefixSortie;
	$pause	 = (int) $planning->$prefixPause;
	$repas	 = (int) $planning->$prefixRepas;
	$coef	 = floatval($planning->coef);

	// Employé
	$employe = $planning->getEmploye();

	// taux Horaire
	$taux = $employe->getTaux();

	// Traitement du Coefficient
	if ($coef == 0) {
	    $coef = $employe->getCoefficient();
	}

	// Test des Données
	switch ($code) {
	    case XRules::Present:
		// Tous les calculs sauf les retards
		$data			 = $this->calculPresent($entree, $sortie, $pause, $repas, $coef, $taux);
		break;
	    case XRules::ProblemeRetardDepartAnticipe:
		// Tous les calculs avec les retards
		$data			 = $this->calculPRDA($entree, $sortie, $pause, $repas, $coef, $taux, $template->$prefixEntree, $template->$prefixSortie);
		break;
	    case XRules::CongePaye:
		// Calcul des jours de disponibilités
		// Pas de pause et pas de repas
		$hebdo			 = $employe->getHoraireHebdo();
		$dispo			 = $employe->getNbJourDispo();
		$data			 = $this->calculCongePaye($coef, $taux, $hebdo, $dispo);
		break;
	    case XRules::NeTravaillePas:
		// pas de repas, pas de pause
		break;
	    case XRules::Absent:
		// L'absence est compté comme retard mais les heures ne sont pas décompté
		// Avec pause et pas de repas
		$data->retard		 = true;
		$dataNormal		 = $this->calculPresent($entree, $sortie, $pause, 0, $coef, $taux);
		$data->tempsRetard	 = $dataNormal->tempsDiff;
		break;
	    case XRules::AccidentTravail:
		// On laisse les heures du planning
		// mais pas de repas, pas de pause
		$data			 = $this->calculPresent($entree, $sortie, 0, 0, $coef, $taux);
		break;
	    case XRules::ArretMaladie1:
		// Les 3 premiers jours les horaires sont décomptés mais pas payés
		$data			 = $this->calculPresent($entree, $sortie, 0, 0, $coef, $taux);
		$data->montant		 = 0.0; // Pas Payés
		break;
	    case XRules::ArretMaladie2:
		// Payé par la société
		$data			 = $this->calculPresent($entree, $sortie, 0, 0, $coef, $taux);
		break;
	    case XRules::CongeMaternite:
		// Comme les congés Payés
		// Pas de Pause et pas de repas
		$hebdo			 = $employe->getHoraireHebdo();
		$dispo			 = $employe->getNbJourDispo();
		$data			 = $this->calculCongePaye($coef, $taux, $hebdo, $dispo);
		break;
	    case XRules::CongeMaternitePere:
		// Comme les congés payés
		// Pas de Pause et pas de repas
		$hebdo			 = $employe->getHoraireHebdo();
		$dispo			 = $employe->getNbJourDispo();
		$data			 = $this->calculCongePaye($coef, $taux, $hebdo, $dispo);
		break;
	    case XRules::CongePayeExceptionnel:
		// Comme les congés payés
		// Pas de Pause et pas de repas
		$hebdo			 = $employe->getHoraireHebdo();
		$dispo			 = $employe->getNbJourDispo();
		$data			 = $this->calculCongePaye($coef, $taux, $hebdo, $dispo);
		break;
	    case XRules::CongeSansSolde:
		// On ne fait rien
		break;
	    case XRules::EcoleFormationIntegration:
		// Horaire obligatoire 08:00 à 15:30 pause et repas
		$data			 = $this->calculPresent($entree, $sortie, $pause, $repas, $coef, $taux);
		break;
	    case XRules::EcoleFormationAlternance:
		// Alternance 3 jour travail, 2 jour ecoles : pas de pause, pas de repas
		$data			 = $this->calculPresent($entree, $sortie, 0, 0, $coef, $taux);
		break;
	    case XRules::EcoleFormationEmploye:
		// Horaire normal
		$data			 = $this->calculPresent($entree, $sortie, $pause, $repas, $coef, $taux);
		break;
	    case XRules::Ferie1:
		// Comme les congés payés pour les plus d'un an d'ancienneté
		$hebdo			 = $employe->getHoraireHebdo();
		$dispo			 = $employe->getNbJourDispo();
		$data			 = $this->calculCongePaye($coef, $taux, $hebdo, $dispo);
		break;
	    case XRules::Ferie2:
		// Pour les Travailleurs qui ont plus 1 an d'ancienneté, il sont payé Double
		$data			 = $this->calculPresent($entree, $sortie, $pause, $repas, $coef, $taux * 2);
		break;
	    case XRules::Ferie3:
		// Pour les travailleur moins 1 an ancienneté et qui travaille un jour ferié : payé simple
		$data			 = $this->calculPresent($entree, $sortie, $pause, $repas, $coef, $taux);
		break;
	    case XRules::Fermer:
		// On ne fait rien
		break;
	    case XRules::Indisponible:
		// On ne fait rien
		break;
	    case XRules::TransfertEntrant:
		// Ce n'est pas ici que l'on calcul les transferts
		break;
	    case XRules::TransfertSortant:
		// Ce n'est pas ici que l'on calcul les transferts
		break;
	    case XRules::Inconnue:
	    default:
		// On ne fait rien
		break;
	}

	return $data;
    }

    /**
     * Calcul des Présences
     *
     * @param int $code
     * @param string $entree
     * @param string $sortie
     * @param int $pause
     * @param int $repas
     * @param float $coef
     * @param float $taux
     * @param array $param
     * @return \RHX\Model\Object\XData
     */
    public function calculPresent($entree, $sortie, $pause, $repas, $coef, $taux, $param = array()) {
	$data = new XData();

	$pauseParam = $pause;

	$pause = $this->getPause($pause);

	$diff	 = RHDateTime::diffHours($sortie, $entree);
	$diff	 = RHDateTime::diffHours($diff, $pause);

	$data->tempsDiff	 = $diff;
	$data->tempsValeur	 = RHDateTime::toFloat($data->tempsDiff);

	$data->montant = $data->tempsValeur * $taux * $coef;

	// Debug
	//$this->Debug("Calcul Normal ($entree, $sortie, $pauseParam, $repas, $coef, $taux) => " . $data->tempsValeur . " x $taux x $coef = " . $data->montant);

	return $data;
    }

    /**
     * Calcul lors des Retards ou Départ anticipé
     *
     * @param string $entree
     * @param string $sortie
     * @param int $pause
     * @param int $repas
     * @param float $coef
     * @param float $taux
     * @param string $refEntree
     * @param string $refSortie
     * @return \RHX\Model\Object\XData
     */
    public function calculPRDA($entree, $sortie, $pause, $repas, $coef, $taux, $refEntree, $refSortie) {
	$data = new XData();

	// Retard
	$tpsRetard = RHDateTime::diffHours($refEntree, $entree);
	if (RHDateTime::toFloat($tpsRetard) > 0) {
	    $data->retard		 = true;
	    $data->tempsRetard	 = $tpsRetard;
	}

	// Départ Anticipé
	$tpsDepartAnticipe = RHDateTime::diffHours($refSortie, $sortie, true, false);
	if (RHDateTime::toFloat($tpsDepartAnticipe) > 0) {
	    $data->anticipe		 = true;
	    $data->tempsAnticipe	 = $tpsDepartAnticipe;
	}

	// Données Normal : Présent
	$dataNormal = $this->calculPresent($entree, $sortie, $pause, $repas, $coef, $taux);

	// Assignation des données
	$data->tempsDiff	 = $dataNormal->tempsDiff;
	$data->tempsValeur	 = $dataNormal->tempsValeur;
	$data->montant		 = $dataNormal->montant;

	return $data;
    }

    /**
     * Calcul pour les Congés Payés
     * 
     * @param float $coef
     * @param float $taux
     * @param float $hebdo
     * @param int $dispo
     * @return \RHX\Model\Object\XData
     */
    public function calculCongePaye($coef, $taux, $hebdo, $dispo) {
	$data = new XData();

	$cpValue		 = $this->getCPValue($hebdo, $dispo);
	$data->tempsDiff	 = RHDateTime::toTime(number_format($cpValue, 2, ',', ''));
	$data->tempsValeur	 = $cpValue;
	$data->montant		 = $data->tempsValeur * $taux * $coef;

	return $data;
    }

    /**
     * Temps de Pause
     * 
     * @param int $pause
     * @return string
     */
    public function getPause($pause) {
	if ($pause == 1) {
	    return '00:30';
	}

	return '00:00';
    }

    /**
     * Nombre d'heure à décompter pour un Congé Payé
     *
     * @param float $hebdo
     * @param int $dispo
     * @return float
     */
    public function getCPValue($hebdo, $dispo) {
	$value = number_format($hebdo / $dispo, 2);

	return floatval($value);
    }

    /**
     * Total des Heures
     * 
     * @param \RHX\Model\Object\XData $dataLundi
     * @param \RHX\Model\Object\XData $dataMardi
     * @param \RHX\Model\Object\XData $dataMercredi
     * @param \RHX\Model\Object\XData $dataJeudi
     * @param \RHX\Model\Object\XData $dataVendredi
     * @param \RHX\Model\Object\XData $dataSamedi
     * @param \RHX\Model\Object\XData $dataDimanche
     * @return type
     */
    public function getTotal(XData $dataLundi, XData $dataMardi, XData $dataMercredi, XData $dataJeudi, XData $dataVendredi, XData $dataSamedi, XData $dataDimanche) {
	// Total des heures Travaillé
	$heureTravaille = new RHDateTime();
	$heureTravaille->setTime();
	$heureTravaille->addHours($dataLundi->tempsDiff, false);
	$heureTravaille->addHours($dataMardi->tempsDiff, false);
	$heureTravaille->addHours($dataMercredi->tempsDiff, false);
	$heureTravaille->addHours($dataJeudi->tempsDiff, false);
	$heureTravaille->addHours($dataVendredi->tempsDiff, false);
	$heureTravaille->addHours($dataSamedi->tempsDiff, false);
	$heureTravaille->addHours($dataDimanche->tempsDiff, false);

	// Debug
	//$this->Debug("lundi : " . $dataLundi->tempsDiff);
	//$this->Debug("mardi : " . $dataMardi->tempsDiff);
	//$this->Debug("mercredi : " . $dataMercredi->tempsDiff);
	//$this->Debug("jeudi : " . $dataJeudi->tempsDiff);
	//$this->Debug("vendredi : " . $dataVendredi->tempsDiff);
	//$this->Debug("samedi : " . $dataSamedi->tempsDiff);
	//$this->Debug("dimanche : " . $dataDimanche->tempsDiff);
	// Total des heures de retard
	$heurePRDA	 = new RHDateTime();
	$heurePRDA->setTime();
	$nbPRDA		 = 0;

	// Lundi
	if ($dataLundi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataLundi->tempsRetard, false);
	}
	if ($dataLundi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataLundi->tempsAnticipe, false);
	}

	// Mardi
	if ($dataMardi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMardi->tempsRetard, false);
	}
	if ($dataMardi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMardi->tempsAnticipe, false);
	}

	// Mercredi
	if ($dataMercredi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMercredi->tempsRetard, false);
	}
	if ($dataMercredi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataMercredi->tempsAnticipe, false);
	}

	// Jeudi
	if ($dataJeudi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataJeudi->tempsRetard, false);
	}
	if ($dataJeudi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataJeudi->tempsAnticipe, false);
	}

	// Vendredi
	if ($dataVendredi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataVendredi->tempsRetard, false);
	}
	if ($dataVendredi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataVendredi->tempsAnticipe, false);
	}

	// Samedi
	if ($dataSamedi->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataSamedi->tempsRetard, false);
	}
	if ($dataSamedi->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataSamedi->tempsAnticipe, false);
	}

	// Dimanche
	if ($dataDimanche->retard) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataDimanche->tempsRetard, false);
	}
	if ($dataDimanche->anticipe) {
	    $nbPRDA++;
	    $heurePRDA->addHours($dataDimanche->tempsAnticipe, false);
	}
//
//	// Debug
//	//$this->Debug("Lundi: " . $dataLundi->tempsDiff);
//	//$this->Debug("Mardi: " . $dataMardi->tempsDiff);
//	//$this->Debug("Mercredi: " . $dataMercredi->tempsDiff);
//	//$this->Debug("Jeudi: " . $dataJeudi->tempsDiff);
//	//$this->Debug("Vendredi: " . $dataVendredi->tempsDiff);
//	//$this->Debug("Samedi: " . $dataSamedi->tempsDiff);
//	//$this->Debug("Dimanche: " . $dataDimanche->tempsDiff);
//	//$this->Debug("Heure Travaille : " . $heureTravaille->totalHours());

	return array(
	    'heureTravaille' => $heureTravaille->totalHours(),
	    'nbPRDA'	 => $nbPRDA,
	    'heurePRDA'	 => $heurePRDA->totalHours(),
	);
    }

    public function getHeureNonPlannifie($matricule, $date) {
	// Periode Table
	$periodeTable = new PeriodeTable($this->getAdapter());

	// Période en cours
	$periode = $periodeTable->getPeriodeByDate($date);
	$periode = new Periode($periode);

	// Planning Semaine table
	$planningTable = new PlanningSemaineTable($this->getAdapter());

	// Plannings de l'employé durant cette période
	$plannings = $planningTable->getPlanningByPeriode($periode, $matricule);

	// Table Employé
	$employeTable = new EmployeTable($this->getAdapter());

	// Employé
	$employe = $employeTable->get($matricule);

	// Periode Semaine Table
	$psTable = new PeriodeSemaineTable($this->getAdapter());

	// Total des heures de la période
	$totalHeurePeriode = new RHDateTime();
	$totalHeurePeriode->setTime();

	// Parcours des plannings
	foreach ($plannings as $pl) {
	    // Template
	    $template = $pl->getTemplate();

	    $dataLundi	 = $this->calculOneDay($pl, $template, 'lundi');
	    $dataMardi	 = $this->calculOneDay($pl, $template, 'mardi');
	    $dataMercredi	 = $this->calculOneDay($pl, $template, 'mercredi');
	    $dataJeudi	 = $this->calculOneDay($pl, $template, 'jeudi');
	    $dataVendredi	 = $this->calculOneDay($pl, $template, 'vendredi');
	    $dataSamedi	 = $this->calculOneDay($pl, $template, 'samedi');
	    $dataDimanche	 = $this->calculOneDay($pl, $template, 'dimanche');

	    $total = $this->getTotal($dataLundi, $dataMardi, $dataMercredi, $dataJeudi, $dataVendredi, $dataSamedi, $dataDimanche);

	    // Debug
	    //$this->Debug("Le Total est " . json_encode($total));

	    $totalHeurePeriode->addHours($total['heureTravaille'], false);

	    // Debug
	    //$this->Debug("Planning ID " . $pl->id);
	    //$this->Debug("Heure Travaille {$total['heureTravaille']}");
	}

	$totalHeure = RHDateTime::toFloat($totalHeurePeriode->totalHours());

	// Total des heures à Faires
	$semaines	 = $psTable->getSemainesByPeriode($periode->id);
	$nbSemaine	 = $semaines->count();
	$totalAfaire	 = $employe->getHoraireHebdo() * $nbSemaine;

	$heureNonPlanifie = $totalHeure - $totalAfaire;

	return floatval($heureNonPlanifie);
    }

    /**
     * Calcul Jour
     *
     * @return \Zend\View\Model\JsonModel
     */
    public function calculJourAction() {
	// POST
	$post = $this->getRequest()
		->getPost();

	// Tables
	$planningTable = new PlanningSemaineTable($this->getAdapter());

	// Planning en cours
	$planning = $planningTable->get($post->id);

	$data = $this->calculJour($planning, $post);

	return new JsonModel(array(
	    'data' => $data,
	));
    }

    /**
     * Calcul Jour
     * 
     * @param \RHX\Model\Object\PlanningSemaine $planning
     * @param type $post
     * @return XData
     */
    public function calculJour(PlanningSemaine $planning, $post) {
	// Préfixe
	$prefix		 = $post->prefix;
	// Préparation des variables dynamiques
	$prefixCode	 = $prefix . '_code';
	$prefixEntree	 = $prefix . '_entree';
	$prefixSortie	 = $prefix . '_sortie';
	$prefixPause	 = $prefix . '_pause';
	$prefixRepas	 = $prefix . '_repas';

	// Assignation et Préparation des variables
	$code	 = (int) $planning->$prefixCode;
	$entree	 = $planning->$prefixEntree;
	$sortie	 = $planning->$prefixSortie;
	$pause	 = (int) $planning->$prefixPause;
	$repas	 = (int) $planning->$prefixRepas;
	$coef	 = floatval($planning->coef);

	// Récupération du code
	$codeActivite = CodeController::getCode($code);

	// Template
	$template = $planning->getTemplate();

	/*
	 * Paramètres supplémentaire
	 */
	// Employe
	$employe = $planning->getEmploye();
	// Congé Payés
	$dataCP	 = $employe->getDataCP();
	$taux	 = $dataCP['taux'];
	$param	 = array(
	    'cp'	 => $dataCP['heureFloat'],
	    'dispo'	 => ($template->$prefixCode == 1) ? true : false,
	);

	$data = $codeActivite->calcul($entree, $sortie, $pause, $repas, $taux, $coef, $template->$prefixEntree, $template->$prefixSortie, $param);

	return $data;
    }

    public function calculSemaineAction() {
	// POST
	$post		 = $this->getRequest()
		->getPost();
	// Table Planning Semaine
	$planningTable	 = new PlanningSemaineTable($this->getAdapter());
	// Planning
	$planning	 = $planningTable->get($post->id);

	$data = $this->calculSemaine($planning);

	return new JsonModel(array(
	    'data' => $data,
	));
    }

    /**
     * Calcul semaine
     * 
     * @param \RHX\Model\Object\PlanningSemaine $planning
     * @return array
     */
    public function calculSemaine(PlanningSemaine $planning) {
	$post			 = $this->getRequest()
		->getPost();
	// Données de Chaque Jour
	$post->prefix		 = 'lundi';
	$dataLundi		 = $this->calculJour($planning, $post);
	$post->prefix		 = 'mardi';
	$dataMardi		 = $this->calculJour($planning, $post);
	$post->prefix		 = 'mercredi';
	$dataMercredi		 = $this->calculJour($planning, $post);
	$post->prefix		 = 'jeudi';
	$dataJeudi		 = $this->calculJour($planning, $post);
	$post->prefix		 = 'vendredi';
	$dataVendredi		 = $this->calculJour($planning, $post);
	$post->prefix		 = 'samedi';
	$dataSamedi		 = $this->calculJour($planning, $post);
	$post->prefix		 = 'dimanche';
	$dataDimanche		 = $this->calculJour($planning, $post);
	// Total des heures Travaillés
	$totalHeureTravaille	 = new RHDateTime();
	$totalHeureTravaille->setTime();
	$totalHeureTravaille->addHours($dataLundi->tempsDiff, false);
	$totalHeureTravaille->addHours($dataMardi->tempsDiff, false);
	$totalHeureTravaille->addHours($dataMercredi->tempsDiff, false);
	$totalHeureTravaille->addHours($dataJeudi->tempsDiff, false);
	$totalHeureTravaille->addHours($dataVendredi->tempsDiff, false);
	$totalHeureTravaille->addHours($dataSamedi->tempsDiff, false);
	$totalHeureTravaille->addHours($dataDimanche->tempsDiff, false);
	// Total des PRDA
	$totalPRDA		 = 0;
	$totalHeurePRDA		 = new RHDateTime();
	$totalHeurePRDA->setTime();
	// Lundi
	if ($dataLundi->retard) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataLundi->tempsRetard, false);
	}
	if ($dataLundi->anticipe) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataLundi->tempsAnticipe, false);
	}
	// Mardi
	if ($dataMardi->retard) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataMardi->tempsRetard, false);
	}
	if ($dataMardi->anticipe) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataMardi->tempsAnticipe, false);
	}
	// Mercredi
	if ($dataMercredi->retard) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataMercredi->tempsRetard, false);
	}
	if ($dataMercredi->anticipe) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataMercredi->tempsAnticipe, false);
	}
	// Jeudi
	if ($dataJeudi->retard) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataJeudi->tempsRetard, false);
	}
	if ($dataJeudi->anticipe) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataJeudi->tempsAnticipe, false);
	}
	// Vendredi
	if ($dataVendredi->retard) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataVendredi->tempsRetard, false);
	}
	if ($dataVendredi->anticipe) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataVendredi->tempsAnticipe, false);
	}
	// Samedi
	if ($dataSamedi->retard) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataSamedi->tempsRetard, false);
	}
	if ($dataSamedi->anticipe) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataSamedi->tempsAnticipe, false);
	}
	// Dimanche
	if ($dataDimanche->retard) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataDimanche->tempsRetard, false);
	}
	if ($dataDimanche->anticipe) {
	    $totalPRDA++;
	    $totalHeurePRDA->addHours($dataDimanche->tempsAnticipe, false);
	}

	// Période
	$periode = new Periode($planning->getPeriode());

	return array(
	    'heureTravaille' => $totalHeureTravaille->totalHours(),
	    'totalHeurePRDA' => $totalHeurePRDA->totalHours(),
	    'totalPRDA'	 => $totalPRDA,
	    'matricule'	 => $planning->matricule,
	    'periodeId'	 => $periode->id,
	    'planningId'	 => $planning->id,
	);
    }

    /**
     * Calcul sur une période
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function calculPeriodeAction() {
	// Post
	$post	 = $this->getRequest()
		->getPost();
	$data	 = $this->calculPeriode($post->id, $post->matricule);

	return new JsonModel($data);
    }

    /**
     * Calcul sur une période
     * 
     * @param int $periodeId
     * @param int $matricule
     * @return XData
     */
    public function calculPeriode($periodeId, $matricule) {
	// Table Periode
	$periodeTable	 = new PeriodeTable($this->getAdapter());
	$periode	 = $periodeTable->get($periodeId);
	// Table Periode Semaine
	$periodeSemaine	 = new PeriodeSemaineTable($this->getAdapter());
	$semaines	 = $periodeSemaine->getSemainesByPeriode($periodeId);
	// Table Planning Semaine
	$planningTable	 = new PlanningSemaineTable($this->getAdapter());
	// Plannings de la période
	$plannings	 = $planningTable->getPlanningByPeriode($periode, $matricule);
	$heureTravaille	 = new RHDateTime();
	$heureTravaille->setTime();
	$prda		 = 0;
	$cp		 = 0;
	$css		 = 0;
	$am1		 = 0;
	$am2		 = 0;
	$at		 = 0;
	$abs		 = 0;
	$heureRetard	 = new RHDateTime();
	$heureRetard->setTime();
	foreach ($plannings as $pl) {
	    // Données globales
	    $data = $this->calculSemaine($pl);
	    $heureTravaille->addHours($data['heureTravaille'], false);
	    $prda += $data['totalPRDA'];
	    $heureRetard->addHours($data['totalHeurePRDA'], false);
	    $cp += $this->compteurCode($pl, XRules::CongePaye);
	    $css += $this->compteurCode($pl, XRules::CongeSansSolde);
	    $am1 += $this->compteurCode($pl, XRules::ArretMaladie1);
	    $am2 += $this->compteurCode($pl, XRules::ArretMaladie2);
	    $at += $this->compteurCode($pl, XRules::AccidentTravail);
	    $abs += $this->compteurCode($pl, XRules::Absent);
	}

	/*
	 * Heures non plannifiés
	 */
	// Table employé
	$employeTable		 = new EmployeTable($this->getAdapter());
	$employe		 = $employeTable->get($matricule);
	$dataCP			 = $employe->getDataCP();
	$hebdo			 = $dataCP['hebdo'];
	$totalHeurePeriode	 = $hebdo * $semaines->count();
	$totalHeureTravaille	 = RHDateTime::toFloat($heureRetard->totalHours());
	$heureNonPlanifie	 = RHDateTime::toTime($totalHeurePeriode - $totalHeureTravaille);

	$data = array(
	    'heureNonPlanifie'	 => $heureNonPlanifie,
	    'heureTravaille'	 => $heureTravaille->totalHours(),
	    'retard'		 => $prda,
	    'heureRetard'		 => $heureRetard->totalHours(),
	    'cp'			 => $cp,
	    'css'			 => $css,
	    'am1'			 => $am1,
	    'am2'			 => $am2,
	    'at'			 => $at,
	    'abs'			 => $abs,
	);

	return $data;
    }

    /**
     * Compteur de code pour une semaine de planning
     * 
     * @param \RHX\Model\Object\PlanningSemaine $planning
     * @param int $code
     * @return int
     */
    public function compteurCode(PlanningSemaine $planning, $code) {
	$prefixs = array(
	    'lundi', 'mardi', 'mercredi', 'vendredi', 'samedi', 'dimanche',
	);
	$nb	 = 0;
	foreach ($prefixs as $prefix) {
	    $prefixCode = $prefix . '_code';
	    if ((int) $planning->$prefixCode == $code) {
		$nb++;
	    }
	}

	return $nb;
    }

    public function comptePersonneAction() {
	$this->layout('layout/ajax');
	$post		 = $this->getPost();
	$refHeure	 = $post->value;
	$tablePlanning	 = new PlanningSemaineTable($this->getAdapter());
	$tableTransfert	 = new \RHX\Model\Table\TransfertTable($this->getAdapter());
	$plannings	 = $tablePlanning->getPlanningsByDate($post->lundi, $post->site);
	//var_dump($post);
	$planning	 = $plannings->current();
	//var_dump($planning);
	$dayPresence	 = array('lundi' => 0, 'mardi' => 0, 'mercredi' => 0, 'jeudi' => 0, 'vendredi' => 0, 'samedi' => 0, 'dimanche' => 0,);
	//$dayPresence['lundi'] = $tablePlanning->countPersonne($planning->lundi, $refHeure, $post->site);
	foreach($dayPresence as $prefix => $presence){
            $sql = $prefix .'_sql';
            $dataPlanning = $tablePlanning->countPersonne($planning->$prefix, $refHeure, $post->site, $prefix);
	    $dayPresence[$prefix] = $dataPlanning['value'];
            $dayPresence[$sql] = $dataPlanning['sql'];
            $dataTransfert = $tableTransfert->countPersonne($planning->$prefix, $refHeure, $post->site);
	    $dayPresence[$prefix] += $dataTransfert['value'];
            $dayPresence[$sql] = $dataTransfert['sql'];
	}
	return new JsonModel($dayPresence);
    }

    /**
     * Comptage du nombre de personne à une heure donnée
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function comptePersonneAction__() {
	// changement de layout
	$this->layout('layout/ajax');
	// post
	$post		 = $this->getRequest()
		->getPost();
	// temps de référence
	$refHeure	 = new RHDateTime();
	$refHeure->setTime($post->value);
	// tables
	$tableEmploye	 = new EmployeTable($this->getAdapter());
	$tablePlanning	 = new PlanningSemaineTable($this->getAdapter());
	$lundi		 = new RHDateTime($post->lundi);
	$dimanche	 = new RHDateTime($post->lundi);
	$dimanche->modify('next sunday');
	$employeList	 = $tablePlanning->getEmployeHavingPlanning($post->site, $lundi->date(), $dimanche->date());
	$employes	 = array();
	foreach ($employeList as $e) {
	    $employes[] = $e->matricule;
	}
	$plannings	 = $tablePlanning->getPlanningByEmploye($lundi->date(), $employes, true);
	//echo "<pre>Il y {$plannings->count()} planning(s) pour les employées de la liste</pre>";
	// variables
	$dayPresence	 = array(
	    'lundi'		 => 0,
	    'mardi'		 => 0,
	    'mercredi'	 => 0,
	    'jeudi'		 => 0,
	    'vendredi'	 => 0,
	    'samedi'	 => 0,
	    'dimanche'	 => 0,
	);
	$dayName	 = array(
	    'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',
	);
	$daysOfWeek	 = array();
	// parcours
	foreach ($plannings as $p) {
	    // Jour de la semaine
	    //echo "<pre>Planning #{$p->id}, matricule : #{$p->matricule}\n</pre>";
	    for ($i = 0; $i < 7; $i++) {
		$day		 = $dayName[$i];
		$dayCode	 = $day . '_code';
		$dayEntree	 = $day . '_entree';
		$daySortie	 = $day . '_sortie';
		$code		 = (int) $p->$dayCode;
		if ($code == XRules::Present ||
			$code == XRules::ProblemeRetardDepartAnticipe ||
			$code == XRules::Ferie2 ||
			$code == XRules::Ferie3 ||
			$code == XRules::EcoleFormationAlternance ||
			$code == XRules::EcoleFormationIntegration ||
			$code == XRules::EcoleFormationEmploye) {
		    $entree	 = new RHDateTime();
		    $sortie	 = new RHDateTime();
		    $entree->setTime($p->$dayEntree);
		    $sortie->setTime($p->$daySortie);
		    if ($refHeure->isBetween($entree, $sortie)) {
			$dayPresence[$day] ++;
		    }
		}
		// date de la semaine
		if (count($daysOfWeek) < 7) {
		    $daysOfWeek[$day] = $p->$day;
		}
	    }
	}
	// transferts
	$tableTransfert = new \RHX\Model\Table\TransfertTable($this->getAdapter());
	foreach ($daysOfWeek as $day => $date) {
	    $entrants = $tableTransfert->getTransfertOfOneDay($date, $post->site, \RHX\Model\Object\Transfert::Entrant);
	    foreach ($entrants as $e) {
		$in	 = new RHDateTime();
		$out	 = new RHDateTime();
		$in->setTime($e->entree);
		$out->setTime($e->sortie);
		if ($refHeure->isBetween($in, $out)) {
		    $dayPresence[$day] ++;
		}
	    }
	}

	return new JsonModel($dayPresence);
    }

    /**
     * Compter le nombre de personne à une heure donnée
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function comptePersonneAction_() {
	// changement de layout
	$this->layout('layout/ajax');
	// post
	$post		 = $this->getRequest()
		->getPost();
	// Temps de référence
	$refHeure	 = new RHDateTime();
	$refHeure->setTime($post->value);
	// tables
	$tableEmploye	 = new EmployeTable($this->getAdapter());
	$tablePlanning	 = new PlanningSemaineTable($this->getAdapter());
	// Liste des employés
	$employeList	 = $tableEmploye->getEmployesBySite($post->site);
	$employes	 = array();
	$lundi		 = new RHDateTime($post->lundi);
	$dimanche	 = new RHDateTime($post->lundi);
	$dimanche->modify('next sunday');
	//$plannings	 = $tablePlanning->getPlanningByEmploye($post->lundi, $employes);
	$plannings	 = array();
	// parcours de la liste des employés
	foreach ($employeList as $e) {
	    $employes[]	 = $e->matricule;
	    $pls		 = $tablePlanning->getPlanningsByDateRange($e->matricule, $lundi->date(), $dimanche->date());
	    foreach ($pls as $p) {
		if ($p) {
		    $plannings[] = $p;
		}
	    }
	}
	// variables
	$dayPresence	 = array(
	    'lundi'		 => 0,
	    'mardi'		 => 0,
	    'mercredi'	 => 0,
	    'jeudi'		 => 0,
	    'vendredi'	 => 0,
	    'samedi'	 => 0,
	    'dimanche'	 => 0,
	);
	$dayName	 = array(
	    'lundi', 'mardi', 'mercredi', 'jeudi', 'vendredi', 'samedi', 'dimanche',
	);
	$daysOfWeek	 = array();
	// parcours des plannings
	$count		 = count($plannings);
	echo "Il y a $count plannings<hr><br>";
	foreach ($plannings as $p) {
	    // parcours des jours de la semaine
	    for ($i = 0; $i < 7; $i++) {
		$day		 = $dayName[$i];
		$dayCode	 = $day . '_code';
		$dayEntree	 = $day . '_entree';
		$daySortie	 = $day . '_sortie';
		$code		 = (int) $p->$dayCode;
		if ($code == XRules::Present || $code == XRules::ProblemeRetardDepartAnticipe || $code == XRules::Ferie2 || $code == XRules::Ferie3 || $code == XRules::EcoleFormationAlternance || $code == XRules::EcoleFormationIntegration || $code == XRules::EcoleFormationEmploye) {
		    $entree	 = new RHDateTime();
		    $sortie	 = new RHDateTime();
		    $entree->setTime($p->$dayEntree);
		    $sortie->setTime($p->$daySortie);
		    //echo "$i - $day - Test de comparaison : " . $refHeure->hours() . ' Entrée :' . $entree->hours() . ' Sortie : ' . $sortie->hours();
		    if ($refHeure->isBetween($entree, $sortie)) {
			$dayPresence[$day] ++;
			if ($day == 'vendredi') {
			    echo "$day #{$p->matricule} - Test de comparaison : " . $refHeure->hours() . ' Entrée :' . $entree->hours() . ' Sortie : ' . $sortie->hours();
			    echo " Présent $day : Résultat {$dayPresence[$day]}<br>";
			}
		    }
		    echo '<hr>';
		}
		// date de la semaine
		if (count($daysOfWeek) < 7) {
		    $daysOfWeek[$day] = $p->$day;
		}
	    }
	    echo "<br><br>";
	}
	\Zend\Debug\Debug::dump($dayPresence, 'Présence avant le comptage des transferts');
	// transferts
	$tableTransfert = new \RHX\Model\Table\TransfertTable($this->getAdapter());
	foreach ($daysOfWeek as $day => $date) {
	    $entrants = $tableTransfert->getTransfertOfOneDay($date, $post->site, \RHX\Model\Object\Transfert::Entrant);
	    foreach ($entrants as $e) {
		$in	 = new RHDateTime();
		$out	 = new RHDateTime();
		$in->setTime($e->entree);
		$out->setTime($e->sortie);
		if ($refHeure->isBetween($in, $out)) {
		    $dayPresence[$day] ++;
		}
	    }
	}
	\Zend\Debug\Debug::dump($dayPresence, 'Présence après le comptage des transferts');

	return new JsonModel($dayPresence);
    }

    /**
     * Vérification des horaires pour les pauses et repas
     * 
     * @return \Zend\View\Model\JsonModel
     */
    public function verifyHourAction() {
	$this->layout('layout/ajax');
	$calculator	 = new \RHX\Model\Object\XCalculator($this->getAdapter());
	$post		 = $this->getRequest()->getPost();
	$pause		 = $calculator->isPause($post->entree, $post->sortie);
	$repas		 = $calculator->isRepas($post->entree, $post->sortie);

	return new JsonModel(array(
	    'pause'	 => $pause,
	    'repas'	 => $repas,
	));
    }

}

?>
